// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_INTERPRETER_BYTECODE_REGISTER_H_
#define V8_INTERPRETER_BYTECODE_REGISTER_H_

#include "src/interpreter/bytecodes.h"

#include "src/base/macros.h"
#include "src/base/platform/platform.h"
#include "src/frame-constants.h"
#include "src/globals.h"

namespace v8 {
namespace internal {
    namespace interpreter {

        // An interpreter Register which is located in the function's Register file
        // in its stack-frame. Register hold parameters, this, and expression values.
        class V8_EXPORT_PRIVATE Register final {
        public:
            explicit Register(int index = kInvalidIndex)
                : index_(index)
            {
            }

            int index() const { return index_; }
            bool is_parameter() const { return index() < 0; }
            bool is_valid() const { return index_ != kInvalidIndex; }

            static Register FromParameterIndex(int index, int parameter_count);
            int ToParameterIndex(int parameter_count) const;

            // Returns an invalid register.
            static Register invalid_value() { return Register(); }

            // Returns the register for the function's closure object.
            static Register function_closure();
            bool is_function_closure() const;

            // Returns the register which holds the current context object.
            static Register current_context();
            bool is_current_context() const;

            // Returns the register for the bytecode array.
            static Register bytecode_array();
            bool is_bytecode_array() const;

            // Returns the register for the saved bytecode offset.
            static Register bytecode_offset();
            bool is_bytecode_offset() const;

            // Returns a register that can be used to represent the accumulator
            // within code in the interpreter, but should never be emitted in
            // bytecode.
            static Register virtual_accumulator();

            OperandSize SizeOfOperand() const;

            int32_t ToOperand() const { return kRegisterFileStartOffset - index_; }
            static Register FromOperand(int32_t operand)
            {
                return Register(kRegisterFileStartOffset - operand);
            }

            static bool AreContiguous(Register reg1, Register reg2,
                Register reg3 = invalid_value(),
                Register reg4 = invalid_value(),
                Register reg5 = invalid_value());

            std::string ToString(int parameter_count) const;

            bool operator==(const Register& other) const
            {
                return index() == other.index();
            }
            bool operator!=(const Register& other) const
            {
                return index() != other.index();
            }
            bool operator<(const Register& other) const
            {
                return index() < other.index();
            }
            bool operator<=(const Register& other) const
            {
                return index() <= other.index();
            }
            bool operator>(const Register& other) const
            {
                return index() > other.index();
            }
            bool operator>=(const Register& other) const
            {
                return index() >= other.index();
            }

        private:
            DISALLOW_NEW_AND_DELETE()

            static const int kInvalidIndex = kMaxInt;
            static const int kRegisterFileStartOffset = InterpreterFrameConstants::kRegisterFileFromFp / kSystemPointerSize;

            int index_;
        };

        class RegisterList {
        public:
            RegisterList()
                : first_reg_index_(Register::invalid_value().index())
                , register_count_(0)
            {
            }
            explicit RegisterList(Register r)
                : RegisterList(r.index(), 1)
            {
            }

            // Returns a new RegisterList which is a truncated version of this list, with
            // |count| registers.
            const RegisterList Truncate(int new_count)
            {
                DCHECK_GE(new_count, 0);
                DCHECK_LT(new_count, register_count_);
                return RegisterList(first_reg_index_, new_count);
            }

            const Register operator[](size_t i) const
            {
                DCHECK_LT(static_cast<int>(i), register_count_);
                return Register(first_reg_index_ + static_cast<int>(i));
            }

            const Register first_register() const
            {
                return (register_count() == 0) ? Register(0) : (*this)[0];
            }

            const Register last_register() const
            {
                return (register_count() == 0) ? Register(0) : (*this)[register_count_ - 1];
            }

            int register_count() const { return register_count_; }

        private:
            friend class BytecodeRegisterAllocator;
            friend class BytecodeDecoder;
            friend class InterpreterTester;
            friend class BytecodeUtils;

            RegisterList(int first_reg_index, int register_count)
                : first_reg_index_(first_reg_index)
                , register_count_(register_count)
            {
            }

            // Increases the size of the register list by one.
            void IncrementRegisterCount() { register_count_++; }

            int first_reg_index_;
            int register_count_;
        };

    } // namespace interpreter
} // namespace internal
} // namespace v8

#endif // V8_INTERPRETER_BYTECODE_REGISTER_H_
